Using fUML as Semantics Specification Language in Model Driven Engineering

In model-driven engineering (MDE), software is developed based on models which hence constitute the central artifacts in the software development process. Consequently, tools supporting MDE, such as model editors, interpreters, and debuggers are crucial in MDE. For developing such tools efficiently, modeling languages have to be defined formally. While for formally defining a modeling language’s syntax standard means exist, this is not the case for defining its semantics. This impedes the efficient development of tools which build upon the modeling language’s semantics, such as model interpreters, debuggers, and testing environments. To overcome this limitation, we present an approach for formally defining the semantics of modeling languages making use of the standardized and UML 2 compliant action language foundational UML (fUML). 1 Problem and Motivation Over the past years, the software development methodology model-driven engineering (MDE) gained significant popularity as it is a promising approach to address the growing complexity of the software systems that have to be built today [17]. In MDE, models are specified using modeling languages to define the structure and behavior of the software to be built. Model transformations and code generation are used to generate different kinds of software artifacts from these models, such as source code and deployment scripts. Because models constitute the central artifacts in MDE, its success depends significantly on the availability of adequate tool support for creating, exploring, analyzing, and utilizing models. In order to develop such tools1 in an efficient way, modeling languages (i.e., their syntax and semantics) have to be defined formally [1]. The abstract syntax of a modeling language defines the modeling language’s concepts and their relations. For formally defining the abstract syntax, metamodels are the standard means. MOF [13] constitutes a standardized, well established, and widely accepted metamodeling language for this purpose. Furthermore, MOF laid the ground for the emergence of a variety of tools building upon the abstract syntax definition of a modeling language, such as techniques for deriving modeling editors from a metamodel and generic components for model serialization, comparison, and transformation. The behavioral semantics of a modeling language defines the execution behavior of conforming models. A formal specification of the behavioral semantics is not only needed for precisely and unambiguously defining the behavior of models, but also to 1 In the remainder of this paper we will refer to tools for MDE, which are based on the definition of a modeling language, as model-based tools. establish the basis for an efficient development of model-based tools which build upon the behavioral semantics of a modeling language, such as model interpreters, debuggers, and testing environments [1]. Having the behavioral semantics of a modeling language explicitly and formally defined enables to automate the development of such tools. Unfortunately, no standard way for defining a modeling language’s behavioral semantics explicitly and formally has been established yet. Hence, formalizing the behavioral semantics of modeling languages remains a core challenge in MDE [1]. To address this challenge we propose to use the standardized and UML 2 compliant action language foundational UML (fUML) [15] as semantics specification language in MDE. 2 Background and Related Work The behavioral semantics of many modeling languages, including widely adopted languages such as UML [14], are only informally defined in natural language. This may lead to several problems, such as to ambiguities in the semantic meaning of the language’s modeling concepts. Furthermore, the behavior of models conforming to the modeling language cannot be formally analyzed and the models cannot be executed. Moreover, building tools, such as model debuggers and interpreters, is problematic if the language’s semantics is only defined in natural language. A commonly used approach to make models executable is to utilize code generators or to develop model interpreters with general-purpose programming languages (GPLs). However, in this approach the behavioral semantics is encoded in the manually constructed code generation templates or model interpreter implementations and hence is only defined implicitly. A problem that arises is that the behavior of models can again not be analyzed easily. Furthermore, the semantics can hardly be extended and reused which makes it costly to create and maintain. To overcome these limitations, adequate techniques for formally and explicitly specifying the behavioral semantics of modeling languages are needed. This need stimulated intensive research resulting in various approaches proposed in the past which can be divided into translational approaches and operational approaches. In translational approaches, models conforming to a modeling language are translated into models conforming to another language whose semantics is formally and explicitly defined. The advantage of this approach is that tools available for the target language can be used for the translated models. Its drawback, however, is that a translation from the source into the target language as well as a mapping of results obtained for the translated models to the original models have to be developed. Examples for translational approaches are the work of Chen et al. [2] and Di Ruscio et al. [4] using the Abstract State Machine formalism as target language, Rivera et al. [16] using Maude, Kühne et al. [9] using Petri nets, and Rumpe et al. [7] using their System Model. In the operational approach, the behavioral semantics is directly introduced into the modeling language without moving to another language. This can be done by utilizing graph transformations as for instance proposed by Engels et al. [6]. Another way is to introduce operations into the metaclasses of a modeling language’s metamodel and provide their implementations using a dedicated action language. Several action languages and GPLs have been proposed for this purpose, such as Kermeta [12], Smalltalk [5], xCore [3], and EOL [8]. 3 Approach and Uniqueness Despite the fact that several approaches for formally and explicitly specifying the behavioral semantics of modeling languages exist, none of these approaches is widely adopted especially in industry. Moreover, the challenge of automatically generating model-based tools from semantics specifications is only addressed by few approaches which provide only partial solutions [1]. We advocate for operational semantics specification approaches because instead of translating models into a different language, the behavioral semantics is directly attached to the modeling language. We also believe that a standardized action language should be employed for this purpose. The action languages proposed until now are either GPLs (e.g., Smalltalk), proprietary languages (e.g., Kermeta), or adapted versions of standardized languages (e.g., xOCL integrated in xCore). In contrast, we propose to use fUML, a standardized and UML 2 compliant action language, for specifying the behavioral semantics of modeling languages. fUML defines the semantics of a subset of UML consisting of concepts for modeling classes and activities formally and provides a virtual machine (VM) for executing compliant models. As both MOF and fUML are standardized by OMG, fUML may be considered as promising candidate for becoming a standardized action language in metamodeling. To use fUML as semantics specification language and leverage the semantics specification of a modeling language to execute conforming models, the following challenges had to be addressed. First, fUML had to be integrated with existing metamodeling languages. Second, state-of-the-art metamodeling methodologies and environments had to be adequately extended to support a systematic and efficient development of behavioral semantics specifications based on fUML. Third, a generic model interpreter had to be developed to enable the execution of models based on the behavioral semantics specification of the modeling language they conform to. To enable the usage of fUML for specifying the behavioral semantics of modeling languages, we identified two strategies: a transformation-based and an integration-based strategy [11]. Because of the better integration with existing metamodeling environments, we decided to apply the integration-based strategy. In this approach, a metamodeling language is extended with the behavioral part of fUML in a way that enables to specify the behavior of the operations introduced for the metaclasses of a modeling language using fUML activities. By applying this approach we extended Ecore, which is integrated with the Eclipse Modeling Framework (EMF) [18] and which constitutes the most prominent implementation of MOF. Thereby we obtained a new metamodeling language which we called executable MOF (xMOF) that enables to specify a modeling language’s abstract syntax using the modeling concepts stemming from Ecore and its behavioral semantics using the modeling concepts stemming from fUML. Based on xMOF we elaborated a tool-supported methodology for developing the behavioral semantics of modeling languages (cf. Figure 1). The input for the semantics specification is the Ecore-based metamodel of a modeling language. As preparatory step we automatically generate a subclass for each metaclass defined in the metamodel. The language designer then adds operations and their implementations in the form of activities to these subclasses, which specify the behavior of the metaclasses. By subclassing the metaclasses for specifying their behavioral semantics, the behavioral semantics specification is clearly separated from the abstract syntax specification. This fUML Model Execution Output